/*
 * @Author: AuroCaffe 18509564594@163.com
 * @Date: 2025-06-13 10:20:51
 * @LastEditors: AuroCaffe 18509564594@163.com
 * @LastEditTime: 2025-09-04 10:48:49
 * @FilePath: \HuiLin\utils\router.js
 * @Description: 路由管理 - 简化版本
 */
import storage from "@/utils/storage.js";
import store from "@/store";

// 白名单页面 - 不需要登录即可访问
const WHITE_LIST = [
	'/pages/index/index', // 首页
	'/pages/index/login', // 登录页
	'/pages/index/mineInfo', // 用户信息页
	'/pages/tabBar/home', // TabBar首页
	'/pages/tabBar/circle', // TabBar圈子
	'/pages/tabBar/mine', // TabBar我的
];

// 登录页面路径
const LOGIN_PAGE = '/pages/index/login';

const router = {
	/**
	 * 检查是否需要认证
	 * @param {string} url 页面路径
	 * @returns {boolean}
	 */
	needAuth(url) {
		// 检查是否在白名单中
		const isWhiteList = WHITE_LIST.some(whitePath => {
			return whitePath === url;
		});

		// 白名单页面不需要认证，其他页面需要认证
		return !isWhiteList;
	},

	/**
	 * 检查是否已登录
	 * @returns {boolean}
	 */
	isLogin() {
		const token = storage.getAccessToken();
		return !!token;
	},

	/**
	 * 检查是否已选择区域
	 * @returns {boolean}
	 */
	isAreaId() {
		const areaId = storage.getAreaId();
		return !!areaId;
	},

	/**
	 * 获取当前页面栈深度
	 * @returns {number}
	 */
	getStackDepth() {
		const pages = getCurrentPages();
		return pages.length;
	},

	/**
	 * 清空页面栈并跳转
	 * @param {string} url 目标页面
	 * @param {string} type 跳转类型
	 * @param {Object} options 额外选项
	 */
	clearStackAndNavigate(url, type = 'redirectTo', options = {}) {
		const pages = getCurrentPages();
		const depth = pages.length;

		// 如果栈深度大于1，先返回多层
		if (depth > 1) {
			const backCount = depth - 1;
			uni.navigateBack({
				delta: backCount,
				success: () => {
					// 返回完成后跳转
					setTimeout(() => {
						const navigationOptions = { url, ...options };
						if (type === 'redirectTo') {
							uni.redirectTo(navigationOptions);
						} else if (type === 'navigateTo') {
							uni.navigateTo(navigationOptions);
						} else if (type === 'switchTab') {
							uni.switchTab(navigationOptions);
						} else if (type === 'reLaunch') {
							uni.reLaunch(navigationOptions);
						}
					}, 100);
				}
			});
		} else {
			// 栈深度为1，直接跳转
			const navigationOptions = { url, ...options };
			if (type === 'redirectTo') {
				uni.redirectTo(navigationOptions);
			} else if (type === 'navigateTo') {
				uni.navigateTo(navigationOptions);
			} else if (type === 'switchTab') {
				uni.switchTab(navigationOptions);
			} else if (type === 'reLaunch') {
				uni.reLaunch(navigationOptions);
			}
		}
	},

	/**
	 * 智能跳转 - 自动处理认证和栈管理
	 * @param {string|Object} urlOrOptions 目标页面URL或包含url的对象
	 * @param {string} preferredType 首选跳转类型
	 */
	smartNavigate(urlOrOptions, preferredType = 'navigateTo') {
		// 兼容两种传参方式：直接传URL字符串或传{url: ''}对象
		let url, options = {};
		
		if (typeof urlOrOptions === 'string') {
			// 直接传递URL字符串
			url = urlOrOptions;
		} else if (typeof urlOrOptions === 'object' && urlOrOptions !== null) {
			// 传递对象，提取url和其他选项
			url = urlOrOptions.url;
			options = { ...urlOrOptions };
			delete options.url; // 移除url，避免重复传递
		} else {
			console.error('[Router] 无效的参数类型:', typeof urlOrOptions);
			return Promise.reject('无效的参数类型');
		}

		// 检查认证
		if (this.needAuth(url)) {
			if (!this.isLogin()) {
				// 检查栈深度，如果已满则清空栈
				if (this.getStackDepth() >= 5) {
					this.clearStackAndNavigate(LOGIN_PAGE, 'redirectTo');
				} else {
					uni.navigateTo({
						url: LOGIN_PAGE
					});
				}
				return Promise.reject('需要登录');
			}
			if (!this.isAreaId()) {
				console.warn(`[Router] 未选择区域，跳转到首页: ${url}`);
				// 检查栈深度，如果已满则清空栈
				if (this.getStackDepth() >= 5) {
					this.clearStackAndNavigate('/pages/index/index', 'redirectTo');
				} else {
					uni.navigateTo({
						url: '/pages/index/index'
					});
				}
				return Promise.reject('需要选择区域');
			}
		}

		// 检查栈深度
		const stackDepth = this.getStackDepth();
		if (stackDepth >= 5) {
			console.warn(`[Router] 页面栈已满(${stackDepth}/5)，清空后跳转`);
			this.clearStackAndNavigate(url, 'redirectTo');
			return Promise.resolve();
		}

		// 正常跳转
		console.log(`[Router] 执行正常跳转: ${url}`);
		const navigationOptions = { url, ...options };
		
		if (preferredType === 'navigateTo') {
			return uni.navigateTo(navigationOptions);
		} else if (preferredType === 'redirectTo') {
			return uni.redirectTo(navigationOptions);
		} else if (preferredType === 'reLaunch') {
			// 警告：reLaunch会断开WebSocket连接
			console.warn(`[Router] 使用reLaunch可能断开WebSocket连接: ${url}`);
			return uni.reLaunch(navigationOptions);
		} else if (preferredType === 'switchTab') {
			return uni.switchTab(navigationOptions);
		}
	},

	/**
	 * navigateTo 方法
	 */
	navigateTo(options) {
		const {
			url
		} = options;
		return this.smartNavigate(url, 'navigateTo');
	},

	/**
	 * redirectTo 方法
	 */
	redirectTo(options) {
		const {
			url
		} = options;
		return this.smartNavigate(url, 'redirectTo');
	},

	/**
	 * switchTab 方法
	 */
	switchTab(options) {
		const {
			url
		} = options;
		return this.smartNavigate(url, 'switchTab');
	},

	/**
	 * 获取未读消息数
	 */
	async getUnreadCount() {
		try {
			const {
				unreadCount
			} = await import('@/api/members.js');
			const response = await unreadCount();
			if (response.data.code === 200) {
				store.commit('SETCOUNT', response.data.data);
			}
		} catch (error) {
			console.error('Failed to get unread count:', error);
		}
	},

	/**
	 * 获取登录页面路径
	 * @returns {string}
	 */
	getLoginPage() {
		return LOGIN_PAGE;
	},

	/**
	 * 获取白名单列表
	 * @returns {Array}
	 */
	getWhiteList() {
		return [...WHITE_LIST];
	},

	/**
	 * 测试路由逻辑
	 * @param {string} url 要测试的URL
	 */
	testRouteLogic(url) {
		console.log(`[Router] 测试路由逻辑: ${url}`);
		console.log(`[Router] 当前登录状态: ${this.isLogin()}`);
		console.log(`[Router] 是否需要认证: ${this.needAuth(url)}`);
		console.log(`[Router] 是否白名单页面: ${!this.needAuth(url)}`);
		console.log(`[Router] 当前栈深度: ${this.getStackDepth()}/5`);
		console.log(`[Router] 登录页面路径: ${this.getLoginPage()}`);
		console.log(`[Router] 白名单列表:`, WHITE_LIST);
	},

	/**
	 * 智能返回函数
	 * 如果页面栈只有1个页面，则跳转到首页；否则正常返回
	 * @param {number} delta 返回的页面数，默认为1
	 */
	smartNavigateBack(delta = 1) {
		const pages = getCurrentPages();
		console.log(`[Router] 智能返回检测 - 当前页面栈深度: ${pages.length}, 返回页数: ${delta}`);
		
		if (pages.length <= 1) {
			// 没有历史页面或只有当前页面，跳转到首页
			console.log('[Router] 页面栈为空，跳转到首页');
			uni.redirectTo({
				url: '/pages/tabBar/home'
			});
		} else if (pages.length <= delta) {
			// 返回页数超过或等于页面栈深度，跳转到首页
			console.log('[Router] 返回页数超过页面栈深度，跳转到首页');
			uni.redirectTo({
				url: '/pages/tabBar/home'
			});
		} else {
			// 正常返回
			console.log('[Router] 执行正常返回');
			uni.navigateBack({ delta });
		}
	}
};

export default router;